Full Stack Web Developer Nanodegree

Part 01 : Programming Fundamentals and the Web

Get started as a developer by mastering object-oriented Python programming, HTML, CSS, and responsive Web design.

• Module 01: Welcome to the Nanodegree
  • Lesson 01: Welcome to the Full Stack Web Developer Nanodegree

    Welcome to the Full Stack Web Developer Nanodegree! Here's an overview of what you'll build in this program.

    • Concept 01: Welcome to the Full Stack Web Developer Nanodegree
  • Lesson 02: Career Services Available to You

    The Careers team at Udacity is here to help you land your dream job - whether it's a new role or growing at your current company. Learn more about how we'll support you in your career growth.

    • Concept 01: Meet the Careers Team
    • Concept 02: Access Your Career Portal
    • Concept 03: Your Udacity Professional Profile
  • Lesson 03: Readiness Assessment

    Ensure you are set up for success in the Nanodegree.

    • Concept 01: Welcome to the Readiness Assessment
    • Concept 02: Introduction
    • Concept 03: Programming Experience
    • Concept 04: Web Development Experience
    • Concept 05: Language Experience
    • Concept 06: Time Commitment
    • Concept 07: Study Habits
    • Concept 08: Readiness Assessment Next Steps
    • Concept 09: What's Next?
  • Lesson 04: Nanodegree Orientation

    Learn how to get help and make the most of your Nanodegree Experience.

    • Concept 01: Welcome to Orientation!
    • Concept 02: Projects and Progress
    • Concept 03: Connecting with Your Community
    • Concept 04: Community Guidelines
    • Concept 05: Support from the Udacity Team
    • Concept 06: How Does Project Submission Work?
    • Concept 07: Integrity and Mindset
    • Concept 08: How Do I Find Time for My Nanodegree?
    • Concept 09: Final Tips
    • Concept 10: Wrapping Up
  • Lesson 05: 15 Minute Code Dive

    Set up a simple Web server on your own computer.

    • Concept 01: 15 Minute Code Dive
  • Lesson 06: Resource Library

    Link to the Full Stack Resource Library.

    • Concept 01: How to Get Help
    • Concept 02: Full Stack Webcasts Archive
• Module 02: Programming Foundations with Python
  • Lesson 01: Introductions

    Review programming fundamentals such as loops and conditionals, and get prepared for your journey deeper into programming.

    • Concept 01: What Will We Create?
    • Concept 02: Comfort Level
    • Concept 03: What Should I Know?
    • Concept 04: Test for Loops
    • Concept 05: Test for If Statements
    • Concept 06: What Will We Learn?
    • Concept 07: Course Map
    • Concept 08: Download Python (Windows)
    • Concept 09: Download Python (Mac)
  • Lesson 02: Use functions

    Use Python functions to build two mini-projects: a break timer that interacts with the web browser, and a program to hide a secret message in a collection of files.

    • Concept 01: Course Map
    • Concept 02: Take a Break (Story)
    • Concept 03: Take a Break (Output)
    • Concept 04: How Would You Do This?
    • Concept 05: Planning the Break
    • Concept 06: One Way of Doing This
    • Concept 07: Launching Python
    • Concept 08: What Is the Error?
    • Concept 09: Squashing the Bug
    • Concept 10: Making the Program Wait
    • Concept 11: Adding a Loop
    • Concept 12: Making the Program Wait Longer
    • Concept 13: Where Does Webbrowser Come From?
    • Concept 14: Reading Webbrowser Documentation
    • Concept 15: Enhancing the Take a Break Project
    • Concept 16: Take a Break Mini-Project
    • Concept 17: Course Map
    • Concept 18: Secret Message (Story)
    • Concept 19: Secret Message (Output)
    • Concept 20: Planning a Secret Message
    • Concept 21: Opening a File
    • Concept 22: Changing Filenames
    • Concept 23: Checking os Documentation
    • Concept 24: Renaming Files
    • Concept 25: What Is the Error?
    • Concept 26: Squashing the Bug
    • Concept 27: Rename Troubles
    • Concept 28: Where Does os Come From?
    • Concept 29: Reading os Documentation
    • Concept 30: Secret Message Mini-Project
    • Concept 31: Edge Case
    • Concept 32: When Functions Do Not Suffice
  • Lesson 03: Use classes: Draw Turtles

    Learn and apply object-oriented programming (OOP) by using Python's turtle graphics library to draw shapes in a graphical interface.

    • Concept 01: Course Map
    • Concept 02: Drawing Turtles (Story)
    • Concept 03: Drawing Turtles (Output)
    • Concept 04: How to Draw a Square
    • Concept 05: Drawing a Square
    • Concept 06: Change Turtle Shape, Color, and Speed
    • Concept 07: Where Does Turtle Come From?
    • Concept 08: Reading Turtle Documentation
    • Concept 09: Two Turtles
    • Concept 10: What's Wrong With This Code?
    • Concept 11: Improving Code Quality
    • Concept 12: What Is a Class?
    • Concept 13: Making a Circle out of Squares
    • Concept 14: Turtle Mini-Project
    • Concept 15: Comfort Level
    • Concept 16: They Look So Similar
  • Lesson 04: Use classes: Send Text

    Advance your use of Python classes in a mini-project: sending text messages to mobile phones via the Twilio service.

    • Concept 01: Course Map
    • Concept 02: Send Text Messages (Story)
    • Concept 03: Send Text Messages (Output)
    • Concept 04: Introducing Twilio
    • Concept 05: Download Twilio
    • Concept 06: Twilio Download Feedback
    • Concept 07: Setting Up Our Code
    • Concept 08: Registering with Twilio
    • Concept 09: Running Our Code
    • Concept 10: Python Keyword From
    • Concept 11: Investigating the Code
    • Concept 12: Where Does Twilio Come From?
    • Concept 13: Connecting Turtle and Twilio
    • Concept 14: Send Text Messages Mini-Project
  • Lesson 05: Use classes: Profanity Editor

    Plan and build a program using advanced Python functions and classes to save your instructor from an embarrassing typo!

    • Concept 01: Course Map
    • Concept 02: Embarrassing Story
    • Concept 03: Planning Profanity Editor
    • Concept 04: Reading from a File
    • Concept 05: Place Function Open
    • Concept 06: Reading Open Documentation
    • Concept 07: Connecting Turtle and Open
    • Concept 08: Built-In Python Functions
    • Concept 09: Checking for Curse Words
    • Concept 10: Accessing a Website with Code
    • Concept 11: Place urllib and urlopen
    • Concept 12: Reading urllib Documentation
    • Concept 13: Printing a Better Output
    • Concept 14: Profanity Editor Mini-Project
    • Concept 15: Connecting Turtle, Open, and Urllib
  • Lesson 06: Make classes: Movie Website

    Apply Python classes to build a website to share images or trailers of your favorite movies.

    • Concept 01: Course Map
    • Concept 02: What Should Class Movie Remember?
    • Concept 03: Defining Class Movie
    • Concept 04: What Happens When
    • Concept 05: Defining __init__
    • Concept 06: What Is Going On Behind the Scenes
    • Concept 07: What Will Be the Output?
    • Concept 08: Behind the Scenes
    • Concept 09: Is Self Important?
    • Concept 10: Next Up: Show_trailer
    • Concept 11: Playing Movie Trailer
    • Concept 12: Play Your Favorite Trailer
    • Concept 13: Recap Vocab
    • Concept 14: Designing the Movie Website
    • Concept 15: Coding the Movie Website
    • Concept 16: Movie Website Mini-Project
    • Concept 17: Comfort Level
  • Lesson 07: Make classes: Advanced Topics

    Explore advanced topics in Python OOP, such as class variables, inheritance, and method overriding.

    • Concept 01: Advanced Ideas in OOP
    • Concept 02: Class Variables
    • Concept 03: Using Predefined Class Variables
    • Concept 04: Inheritance
    • Concept 05: Class Parent
    • Concept 06: What's the Output?
    • Concept 07: Class Child
    • Concept 08: Transitioning to Class Movie
    • Concept 09: Updating the Design for Class Movie
    • Concept 10: Reusing Methods
    • Concept 11: Method Overriding
    • Concept 12: Next Stop - Final Project
• Module 03: Project: Movie Website
  • Lesson 01: Movie Trailer Website

    You will write server-side code to store a list of your favorite movies, including box art imagery and a movie trailer URL.

    Project Description - Movie Trailer Website

    Project Rubric - Movie Trailer Website

    • Concept 01: Project Overview
    • Concept 02: Project Display Example
    • Concept 03: Project Details
• Module 04: Intro to HTML and CSS
  • Lesson 01: HTML, CSS, and Boxes

    Follow along as Jessica Uelmen and Cameron Pittman show you how to use HTML and CSS to create box style layouts.

    • Concept 01: The First Step
    • Concept 02: Exploring the Web
    • Concept 03: Page Structure
    • Concept 04: Summary of HTML
    • Concept 05: Visual Styling
    • Concept 06: HTML-CSS-DOM
    • Concept 07: Boxes Everywhere
    • Concept 08: Boxes, Grids and Rules
    • Concept 09: Boxifying Design
    • Concept 10: Interview with Jacques
    • Concept 11: Boxes To HTML
    • Concept 12: Quiz: Creating the Files
    • Concept 13: Adding Style
    • Concept 14: Understanding CSS
    • Concept 15: Styling Up
    • Concept 16: Using Semantic Tags
    • Concept 17: The Box Revisited
    • Concept 18: Positioning Boxes
    • Concept 19: Adding Image
    • Concept 20: Code, Test, Refine
    • Concept 21: More on DevTools
    • Concept 22: Comparing with the Design
    • Concept 23: Verifying HTML and CSS
    • Concept 24: Conclusion
  • Lesson 02: CSS Frameworks, Responsive Layouts

    Learn how to create grid-based responsive web layouts that look great on any device, from desktop to mobile.

    • Concept 01: Intro
    • Concept 02: Grid Based Design
    • Concept 03: Building a Framework
    • Concept 04: Responsive Web Pages
    • Concept 05: Defining the Layout
    • Concept 06: Creating the Project
    • Concept 07: From Idea to Code
    • Concept 08: Framework Version 01
    • Concept 09: Negative Space
    • Concept 10: Overflows
    • Concept 11: Media Specific CSS
    • Concept 12: CSS Resetting
    • Concept 13: Your Problem Has Been Solved Before
    • Concept 14: Applying the Framework
    • Concept 15: Semantic Structure
    • Concept 16: Tuning the Page
    • Concept 17: Continuous Improvement
    • Concept 18: Code, Test, Refine, Repeat
    • Concept 19: Conclusion
  • Lesson 03: Bootstrap and Other Frameworks

    Learn the ins and outs of Bootstrap, the most popular CSS framework in use today.

    • Concept 01: Intro
    • Concept 02: Site Structure
    • Concept 03: Choosing a Framework
    • Concept 04: Reading Documentation
    • Concept 05: Choosing Features
    • Concept 06: Minified CSS Files
    • Concept 07: Exploring the Framework
    • Concept 08: Applying Bootstrap Grid System
    • Concept 09: Responsive Page
    • Concept 10: Using Bootstrap Typography
    • Concept 11: Custom CSS for Your Site
    • Concept 12: Watch a Front End Engineer Do This
    • Concept 13: Watch a Front End Engineer Do This pt. 2
    • Concept 14: A Small Taste of Interactivity
    • Concept 15: Self-built Framework vs Existing
    • Concept 16: Conclusion
• Module 05: Responsive Web Design Fundamentals
  • Lesson 01: Why Responsive?

    Pete Lepage, Developer Advocate at Google, explains why responsive design is so important and helps you set up your development environment.

    • Concept 01: Sites On Mobile
    • Concept 02: Share Your Great & Awful Sites
    • Concept 03: Intro to Project
    • Concept 04: Pan, Zoom, Touch, Ick
    • Concept 05: Emulators, Simulators and Real Devices
    • Concept 06: Setting up Chrome's Dev Tools
    • Concept 07: Remote Debugging Intro
    • Concept 08: Setup for Mobile
    • Concept 09: Using Dev Tools on Mobile
    • Concept 10: Mobile Tools for iOS
    • Concept 11: Lesson Summary
  • Lesson 02: Starting Small

    Dive into the specifics of how pixels on a webpage are rendered and how that impacts the development process.

    • Concept 01: Defining the Viewport
    • Concept 02: Pixels, pixels and moar pixels!
    • Concept 03: Pixelation
    • Concept 04: Calculating DPR
    • Concept 05: What's the difference?
    • Concept 06: Calculating CSS Pixels
    • Concept 07: How wide is the viewport?
    • Concept 08: Setting the Viewport
    • Concept 09: Large Fixed Width Elements
    • Concept 10: Max-width on elements
    • Concept 11: Relative Sizes
    • Concept 12: Tap Target Sizes
    • Concept 13: Tap Targets
    • Concept 14: Start Small
    • Concept 15: Project Part 1
    • Concept 16: Project Solution - Long
    • Concept 17: Lesson Summary
  • Lesson 03: Building Up

    Learn the most important tools in developing any responsive web application: media queries and flexbox.

    • Concept 01: Lesson Intro
    • Concept 02: Basic Media Query Intro
    • Concept 03: Adding a Basic Media Query
    • Concept 04: Adding a basic media query 2
    • Concept 05: Next Step Media Queries
    • Concept 06: Breakpoints
    • Concept 07: Breakpoints Pt. II
    • Concept 08: Number of Breakpoints
    • Concept 09: Picking Breakpoints
    • Concept 10: Picking Breakpoints 2
    • Concept 11: Pick a Breakpoint
    • Concept 12: Complex Media Queries
    • Concept 13: What Styles Are Applied?
    • Concept 14: Grids
    • Concept 15: Flexbox Intro
    • Concept 16: Flexbox Container
    • Concept 17: Flex Item
    • Concept 18: Deconstructing a Flexbox Layout
    • Concept 19: Deconstructing a Flexbox Layout
    • Concept 20: Lesson Summary
  • Lesson 04: Common Responsive Patterns

    Walk through the most popular responsive layout patterns and learn the tools needed to implement them in your own designs.

    • Concept 01: Intro to Patterns
    • Concept 02: Pattern - Column Drop
    • Concept 03: Pattern - Mostly Fluid
    • Concept 04: Mostly Fluid Part 1
    • Concept 05: Mostly Fluid Part 2
    • Concept 06: Combining Fluid Layouts
    • Concept 07: Pattern - Layout Shifter
    • Concept 08: Which is Which?
    • Concept 09: Pattern - Off Canvas
    • Concept 10: Off Canvas Visualization
    • Concept 11: Project Update Part 2
    • Concept 12: Lesson Summary
  • Lesson 05: Optimizations

    Learn how to optimize images, tables, and fonts to make for the best responsive layouts.

    • Concept 01: Lesson Intro
    • Concept 02: Images
    • Concept 03: Responsive Tables Intro
    • Concept 04: Responsive Tables - Hidden Columns
    • Concept 05: Hide Some Columns
    • Concept 06: Responsive Tables - No More Tables
    • Concept 07: Responsive Tables - Contained Scrolling
    • Concept 08: Fonts
    • Concept 09: Minor Breakpoints
    • Concept 10: Final Project Updates
    • Concept 11: Wrap Up
• Module 06: Responsive Images
  • Lesson 01: Getting Up and Running

    Sam Dutton, developer advocate at Google, explains the importance of getting responsive images right and helps you setup mobile developer tools.

    • Concept 01: Course Introduction
    • Concept 02: Why Responsive Images?
    • Concept 03: Intro to Project
    • Concept 04: Setting up Your Environment
    • Concept 05: Setup for Mobile
    • Concept 06: Using Dev Tools on Mobile
    • Concept 07: Mobile Tools for iOS
    • Concept 08: Lesson Wrap Up
  • Lesson 02: Units, Formats, Environments

    Optimize images to display beautifully on all screen sizes. Learn about the difference between Raster vs Vector images, responsive CSS units, and setting up optimization tools.

    • Concept 01: Sizing Intro
    • Concept 02: All about Bits and Pixels
    • Concept 03: Requests and Revenue
    • Concept 04: Relative Sizing
    • Concept 05: IMPORTANT! Udacity Front End Feedback Extension
    • Concept 06: calc()
    • Concept 07: Landscape and Portrait
    • Concept 08: Less Well Known CSS Units
    • Concept 09: Raster and Vector
    • Concept 10: Raster or Vector Banner?
    • Concept 11: Raster and Vector Identification
    • Concept 12: File formats
    • Concept 13: Spot the Differences
    • Concept 14: Spot the Differences 2
    • Concept 15: Image Compression
    • Concept 16: Project Part 1
    • Concept 17: Lesson Summary
  • Lesson 03: Images with Markup

    Dive deep into image alternatives like CSS and icon fonts and learn common strategies to alleviate latency.

    • Concept 01: Performance
    • Concept 02: Text Problems
    • Concept 03: CSS Techniques
    • Concept 04: CSS background images
    • Concept 05: CSS background image techniques
    • Concept 06: Symbol characters
    • Concept 07: Unicode Treble Clef
    • Concept 08: Icon Fonts
    • Concept 09: Inlining images with SVG and data URIs
    • Concept 10: Strategy Quiz 1
    • Concept 11: Strategy Quiz 2
    • Concept 12: Strategy Quiz 3
    • Concept 13: Strategy Quiz 4
    • Concept 14: Project Part 2
    • Concept 15: Lesson Summary
  • Lesson 04: Full Responsiveness

    Learn to use the srcset attribute and the picture element to choose images of the right size for your application for every viewing context.

    • Concept 01: Responding to Screen Capability & View
    • Concept 02: srcset
    • Concept 03: Sizes Attribute
    • Concept 04: srcset Quiz
    • Concept 05: srcset and sizes
    • Concept 06: The Picture Element
    • Concept 07: The Full Monty
    • Concept 08: Accessibility
    • Concept 09: Accessibility Promise
    • Concept 10: Project Part 3
    • Concept 11: Course Conclusion
• Module 07: Build a Portfolio Site
  • Lesson 01: Build a Portfolio Site

    Given a pdf mockup of a website from a designer, translate it to a real website using your HTML and CSS skills.

    Project Description - Build a Portfolio Site

    Project Rubric - Build a Portfolio Site

    • Concept 01: Project Overview
    • Concept 02: Instructions

Part 02 (Career): Career: Job Search Strategies

Opportunity can come when you least expect it, so when your dream job comes along, you want to be ready.

• Module 01: Conduct a Job Search
  • Lesson 01: Conduct a Job Search

    Learn how to search for jobs effectively through industry research, and targeting your application to a specific role.

    • Concept 01: Introduction
    • Concept 02: Job Search Mindset
    • Concept 03: Target Your Application to An Employer
    • Concept 04: Open Yourself Up to Opportunity
    • Concept 05: Resources in Your Career Portal
• Module 02: Refine Your Resume
  • Lesson 01: Refine Your Entry-Level Resume

    Receive a personalized review of your resume. This resume review is best suited for applicants who have 0-3 years of work experience in any industry.

    Project Description - Resume Review Project (Entry-level)

    Project Rubric - Resume Review Project (Entry-level)

    • Concept 01: Convey Your Skills Concisely
    • Concept 02: Effective Resume Components
    • Concept 03: Resume Structure
    • Concept 04: Describe Your Work Experiences
    • Concept 05: Resume Reflection
    • Concept 06: Resume Review
    • Concept 07: Resume Review (Entry-level)
    • Concept 08: Resources in Your Career Portal
  • Lesson 02: Refine Your Career Change Resume

    Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in an unrelated field.

    Project Description - Resume Review Project (Career Change)

    Project Rubric - Resume Review Project (Career Change)

    • Concept 01: Convey Your Skills Concisely
    • Concept 02: Effective Resume Components
    • Concept 03: Resume Structure
    • Concept 04: Describe Your Work Experiences
    • Concept 05: Resume Reflection
    • Concept 06: Resume Review
    • Concept 07: Resume Review (Career Change)
    • Concept 08: Resources in Your Career Portal
  • Lesson 03: Refine Your Prior Industry Experience Resume

    Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in a related field.

    Project Description - Resume Review Project (Prior Industry Experience)

    Project Rubric - Resume Review Project (Prior Industry Experience)

    • Concept 01: Convey Your Skills Concisely
    • Concept 02: Effective Resume Components
    • Concept 03: Resume Structure
    • Concept 04: Describe Your Work Experiences
    • Concept 05: Resume Reflection
    • Concept 06: Resume Review
    • Concept 07: Resume Review (Prior Industry Experience)
    • Concept 08: Resources in Your Career Portal
• Module 03: Write an Effective Cover Letter
  • Lesson 01: Craft Your Cover Letter

    Get a personalized review of your cover letter. A successful cover letter will convey your enthusiasm, specific technical qualifications, and communication skills applicable to the position.

    Project Description - Craft Your Cover Letter

    Project Rubric - Craft Your Cover Letter

    • Concept 01: Get an Interview with a Cover Letter!
    • Concept 02: Purpose of the Cover Letter
    • Concept 03: Cover Letter Components
    • Concept 04: Write the Introduction
    • Concept 05: Write the Body
    • Concept 06: Write the Conclusion
    • Concept 07: Format
    • Concept 08: Resources in Your Career Portal

Part 03 : Web Applications and Development

Build your skills as a web developer by diving deeper into the tools, including HTML forms, databases, and the Git version control system.

• Module 01: Intro to Backend
  • Lesson 01: Introduction

    Learn how to install Python and Google App Engine.

    • Concept 01: Install Google App Engine
  • Lesson 02: Forms and Inputs

    Learn about forms and how to handle inputs from your users.

    • Concept 01: Introduction
    • Concept 02: Forms
    • Concept 03: User Input
    • Concept 04: Naming Input
    • Concept 05: Entering Input
    • Concept 06: Submitting Input
    • Concept 07: The Action Attribute
    • Concept 08: URL Encoding
    • Concept 09: Hello Webapp World
    • Concept 10: Content Type
    • Concept 11: More Handlers
    • Concept 12: The Method Attribute
    • Concept 13: Methods and Parameters
    • Concept 14: Differences Between Get and Post
    • Concept 15: Problems with Get
    • Concept 16: When to Use Get and Post
    • Concept 17: Passwords
    • Concept 18: Checkboxes
    • Concept 19: Multiple Checkboxes
    • Concept 20: Radio Buttons
    • Concept 21: Grouping Radio Buttons
    • Concept 22: Radio Button Values
    • Concept 23: Label Elements
    • Concept 24: Dropdowns
    • Concept 25: Dropdowns and Values
    • Concept 26: The Number One
    • Concept 27: Validation
    • Concept 28: What Is Your Birthday?
    • Concept 29: Handling Posts
    • Concept 30: Handling Bad Data
    • Concept 31: Valid Month
    • Concept 32: Valid Day
    • Concept 33: Valid Year
    • Concept 34: Checking Validation
    • Concept 35: Responding Based On Verification
    • Concept 36: String Substitution
    • Concept 37: Substituting Multiple Strings
    • Concept 38: Advanced String Substitution
    • Concept 39: Substituting into Our Form
    • Concept 40: Preserving User Input
    • Concept 41: Problems with HTML Input
    • Concept 42: Handling HTML Input
    • Concept 43: HTML Escaping
    • Concept 44: Using HTML Escaping
    • Concept 45: Implementing HTML Escaping
    • Concept 46: Problems Reinventing the Wheel
    • Concept 47: Current Limitations
    • Concept 48: Redirection
    • Concept 49: Redirection Advantages
    • Concept 50: Implementing Redirection
  • Lesson 03: Templates

    Learn about how to use templates.

    • Concept 01: Writing a Basic Form
    • Concept 02: Hidden Inputs
    • Concept 03: Shopping List Take 1
    • Concept 04: Possible Problems
    • Concept 05: Introducing Templates
    • Concept 06: Template Refactor
    • Concept 07: Variable Substitution
    • Concept 08: Statement Syntax
    • Concept 09: Testing Statement Syntax
    • Concept 10: Templates and Types
    • Concept 11: For Loop Syntax
    • Concept 12: FizzBuzz
    • Concept 13: Shopping List Take 2
    • Concept 14: Escaping Templates
    • Concept 15: Helpful Tips
    • Concept 16: Template Inheritance
    • Concept 17: FizzBuzz Inheritance
    • Concept 18: Conclusion
  • Lesson 04: Problem Set: Forms and Templates

    Problem set on templates.

    • Concept 01: Rot13
    • Concept 02: User Signup
    • Concept 03: Rot13 Solution
    • Concept 04: User Signup Solution
  • Lesson 05: Databases

    Learn how to work with databases.

    • Concept 01: Databases
    • Concept 02: Databases Continued
    • Concept 03: What Is a Database?
    • Concept 04: Tables
    • Concept 05: Implementing Tables in Python
    • Concept 06: Querying
    • Concept 07: Why Databases?
    • Concept 08: Types of Databases
    • Concept 09: SQL
    • Concept 10: Databases in Python
    • Concept 11: More Advanced SQL
    • Concept 12: Advanced SQL in Python
    • Concept 13: Order By
    • Concept 14: Joins
    • Concept 15: Indexes
    • Concept 16: Querying Links
    • Concept 17: Using Dictionaries As Indices
    • Concept 18: Lookup
    • Concept 19: Advantages of Indices
    • Concept 20: Real-World Example
    • Concept 21: Indices for Sorting
    • Concept 22: Another Real-World Example
    • Concept 23: Growing Databases
    • Concept 24: ACID
    • Concept 25: Google App Engine Datastore
    • Concept 26: GQL
    • Concept 27: Automatic Sharding and Replication
    • Concept 28: ASCII Chan
    • Concept 29: Getting Started on ASCII Chan
    • Concept 30: Creating the Form
    • Concept 31: Textarea
    • Concept 32: Form Handling
    • Concept 33: Form Handling Continued
    • Concept 34: Creating Entities
    • Concept 35: Datastore Types
    • Concept 36: Creating Entities Continued
    • Concept 37: Working with Entities
    • Concept 38: Running Queries
    • Concept 39: Styling
  • Lesson 06: Problem Set: Databases

    Problem set on databases.

    • Concept 01: Basic Blog
    • Concept 02: Solution Part 1
    • Concept 03: Solution Part 2
    • Concept 04: Solution Part 3
    • Concept 05: Solution Part 4
    • Concept 06: Solution Part 5
  • Lesson 07: User Accounts & Security

    Build a complete login system to authenticate your users.

    • Concept 01: Authentication
    • Concept 02: Cookies
    • Concept 03: Good Uses for Cookies
    • Concept 04: Cookie Headers
    • Concept 05: Cookie Examples
    • Concept 06: Sending Cookies
    • Concept 07: Setting Cookies
    • Concept 08: Cookie Domains
    • Concept 09: Valid Receivers
    • Concept 10: Valid Setters
    • Concept 11: Cookie Settings
    • Concept 12: Ad Networks
    • Concept 13: Cookie Expiration
    • Concept 14: Cookie Deletion
    • Concept 15: Cookies in App Engine
    • Concept 16: Cheating
    • Concept 17: How to Cheat
    • Concept 18: Hashing
    • Concept 19: Hash Algorithms
    • Concept 20: Hashing in Python
    • Concept 21: Hashlib and SHA256
    • Concept 22: Hashing Cookies
    • Concept 23: Making Hashed Cookies
    • Concept 24: Verifying Hashed Cookies
    • Concept 25: Putting It Together
    • Concept 26: Cookie Hashing
    • Concept 27: HMAC
    • Concept 28: Incorporating HMAC
    • Concept 29: Password Hashing
    • Concept 30: Why Hash Passwords?
    • Concept 31: Storytime
    • Concept 32: Hash Your Passwords
    • Concept 33: Rainbow Tables
    • Concept 34: Making Salts
    • Concept 35: Hashing Salts
    • Concept 36: Validating Salts
    • Concept 37: Bcrypt
    • Concept 38: HTTPS
    • Concept 39: Which hashing algorithm?
  • Lesson 08: Problem Set: User Accounts & Security

    Problem set on setting up user logins.

    • Concept 01: Registration
    • Concept 02: Login
    • Concept 03: Logout
    • Concept 04: Registration Solution
    • Concept 05: Login Solution
    • Concept 06: Logout Solution
• Module 02: Project: Multi User Blog
  • Lesson 01: Multi User Blog

    Build your multi user blog.

    Project Description - Multi User Blog

    Project Rubric - Multi User Blog

    • Concept 01: Project Overview
    • Concept 02: Getting Started

Part 04 : The Backend: Databases & Applications

Master SQL databases and build multi-user web applications using the Flask framework, SQLAlchemy, and authentication providers such as Google and Facebook.

• Module 01: Intro to Relational Databases
  • Lesson 01: Data and Tables

    Learn the principles behind relational data organization: tables, queries, aggregations, keys, and joins.

    • Concept 01: Welcome to RDB
    • Concept 02: What's a Database
    • Concept 03: Looking at Tables
    • Concept 04: Data Types and Meaning
    • Concept 05: Data Meanings
    • Concept 06: Zoo
    • Concept 07: Anatomy of a Table
    • Concept 08: Answering Questions from a Table
    • Concept 09: Aggregations
    • Concept 10: Queries and Results
    • Concept 11: How Queries Happen
    • Concept 12: Favorite Animals
    • Concept 13: Related Tables
    • Concept 14: Uniqueness and Keys
    • Concept 15: Primary Key
    • Concept 16: Joining Tables
    • Concept 17: Database Concepts
    • Concept 18: Summary
  • Lesson 02: Elements of SQL

    Start learning SQL by using the select and insert statements to read and write data in database tables.

    • Concept 01: SQL is for Elephants
    • Concept 02: Talk to the Zoo Database
    • Concept 03: Types in the SQL World
    • Concept 04: Just a few SQL types
    • Concept 05: Select Where
    • Concept 06: Comparison Operators
    • Concept 07: The One Thing SQL is Terrible At
    • Concept 08: The Experiment Page
    • Concept 09: Select Clauses
    • Concept 10: Why Do It in the Database
    • Concept 11: Count all the Species
    • Concept 12: Insert: Adding Rows
    • Concept 13: Find the Fish Eaters
    • Concept 14: After Aggregating
    • Concept 15: More Join Practice
    • Concept 16: Wrap up
    • Concept 17: Installing the Virtual Machine
  • Lesson 03: Python DB-API

    Learn the Python database API, and apply your knowledge to fix common bugs that arise in database-backed web services.

    • Concept 01: Welcome to your Database
    • Concept 02: What's a DB-API
    • Concept 03: Writing Code with DB API
    • Concept 04: Trying out DB API
    • Concept 05: Inserts in DB API
    • Concept 06: Running the Forum
    • Concept 07: Hello PostgreSQL
    • Concept 08: Give That App a Backend
    • Concept 09: Bobby Tables, Destroyer of Posts
    • Concept 10: Curing Bobby Tables
    • Concept 11: Spammy Tables
    • Concept 12: Stopping the Spam
    • Concept 13: Updating Away the Spam
    • Concept 14: Deleting the Spam
    • Concept 15: Conclusion
  • Lesson 04: Deeper into SQL

    Create your own database tables using normalized table design, using keys to declare relationships between tables; then apply these relationships to draw conclusions from data.

    • Concept 01: Intro to Creating Tables
    • Concept 02: Normalized Design Part One
    • Concept 03: Normalized Design Part Two
    • Concept 04: What's Normalized
    • Concept 05: Create Table and Types
    • Concept 06: Creating and Dropping
    • Concept 07: Declaring Primary Keys
    • Concept 08: Declaring Relationships
    • Concept 09: Foreign Keys
    • Concept 10: Self Joins
    • Concept 11: Counting What Isn't There
    • Concept 12: Subqueries
    • Concept 13: One Query Not Two
    • Concept 14: Views
    • Concept 15: Outro
• Module 02: Project: Tournament Results Database
  • Lesson 01: Tournament Database

    Build a database backed application that determines the winner of a swiss-style game tournament.

    Project Description - Design a Tournament Results Database

    Project Rubric - Design a Tournament Results Database

    • Concept 01: Final Project Tournament
    • Concept 02: Mathematical
    • Concept 03: What's in the Database
    • Concept 04: Ready to Play
    • Concept 05: Course Outro
    • Concept 06: Project Overview
    • Concept 07: Project Description
    • Concept 08: Project Details
• Module 03: Full Stack Foundations
  • Lesson 01: Working with CRUD

    Learn the CRUD pattern (Create, Read, Update, Delete) and how it relates to RESTful architectures and to the operations of a database-backed web service.

    • Concept 01: Course Intro
    • Concept 02: Prerequisites & Preparation
    • Concept 03: Project Introduction - CRUD
    • Concept 04: CRUD Review 1
    • Concept 05: CRUD Review 2
    • Concept 06: CRUD Review 3
    • Concept 07: CRUD Review 4
    • Concept 08: SQL
    • Concept 09: SQL Quiz Select
    • Concept 10: SQL Insert Into
    • Concept 11: SQL Update
    • Concept 12: SQL Delete
    • Concept 13: Creating a Database and ORMs
    • Concept 14: Introducing SQLAlchemy
    • Concept 15: Creating a Database - Configuration
    • Concept 16: Creating a Database - Class and Table
    • Concept 17: Creating a Database - Mapper
    • Concept 18: Putting It All Together
    • Concept 19: Database Setup Quiz Part 1
    • Concept 20: Database Setup Quiz Part 2
    • Concept 21: CRUD Create
    • Concept 22: CRUD Create Quiz
    • Concept 23: CRUD Read
    • Concept 24: CRUD Read Quiz
    • Concept 25: CRUD Update
    • Concept 26: CRUD Update Quiz
    • Concept 27: CRUD Delete
    • Concept 28: CRUD Delete Quiz
    • Concept 29: CRUD Review
    • Concept 30: Wrap Up
  • Lesson 02: Making a Web Server

    Build a web service in Python that uses your database to implement CRUD operations.

    • Concept 01: Lesson 2 Introduction
    • Concept 02: Review of Clients, Servers and Protocols
    • Concept 03: HTTP and Response Codes
    • Concept 04: Building a Server with HTTPBaseServer
    • Concept 05: Running a Web Server
    • Concept 06: Port Forwarding
    • Concept 07: Responding to Multiple GET Requests
    • Concept 08: Hola Server
    • Concept 09: Adding POST to web server
    • Concept 10: Running the POST Web Server
    • Concept 11: Adding CRUD to our Website
    • Concept 12: CRUD Objectives
    • Concept 13: Adding CRUD Hints
    • Concept 14: CRUD Hints
    • Concept 15: Objective 1
    • Concept 16: Objective 2
    • Concept 17: Objective 3
    • Concept 18: Objective 4
    • Concept 19: Objective 5
    • Concept 20: Lesson 2 Wrap-Up
  • Lesson 03: Developing with frameworks

    Apply the Flask framework in Python to build web services more quickly and reliably.

    • Concept 01: Introducing Frameworks and Flask
    • Concept 02: Lesson 3 Overview
    • Concept 03: Running Your First Flask Application
    • Concept 04: First Flask App Quiz
    • Concept 05: Adding Database to Flask Application
    • Concept 06: Adding Database to Flask Application Quiz
    • Concept 07: Routing
    • Concept 08: Routing Create Quiz
    • Concept 09: Templates
    • Concept 10: Templates Quiz
    • Concept 11: URL for Quiz
    • Concept 12: Form Requests and Redirects
    • Concept 13: Edit Menu Item Form Quiz
    • Concept 14: Delete Menu Item
    • Concept 15: Message Flashing
    • Concept 16: Message Flashing Quiz
    • Concept 17: Styling
    • Concept 18: Responding With JSON
    • Concept 19: JSON Quiz
    • Concept 20: Lesson 3 Wrap-Up
  • Lesson 04: Iterative Development

    Learn the basics of agile and iterative development while building a restaurant menu application.

    • Concept 01: Lesson 4 Introduction
    • Concept 02: Iterative Development
    • Concept 03: Tackling a Complex Project
    • Concept 04: Mockups Exercise
    • Concept 05: Adding Routes
    • Concept 06: Adding Templates and Forms
    • Concept 07: CRUD Functionality
    • Concept 08: API Endpoints
    • Concept 09: Styling Your App
    • Concept 10: Wrap-Up
• Module 04: Authentication and Authorization
  • Lesson 01: Authentication vs Authorization

    Learn the difference between authentication and authorization and some best practices in developing a login system.

    • Concept 01: Intro
    • Concept 02: Course Map
    • Concept 03: Authentication
    • Concept 04: Authentication is hard
    • Concept 05: Implementing Authentication is Hard
    • Concept 06: Using Third Party Auth Providers
    • Concept 07: Authorization
    • Concept 08: Authentication without Authorization
    • Concept 09: Auth providers
    • Concept 10: Pros and Cons using Third Party
    • Concept 11: Follow the Flow
    • Concept 12: Outro
  • Lesson 02: Creating Google Sign in

    Investigate OAuth and build third-party sign-in into your web applications using Google's authentication services.

    • Concept 01: Intro to Lesson 2
    • Concept 02: Types of Flow
    • Concept 03: Google+ Auth for server side apps
    • Concept 04: Step 0 Get initial app running
    • Concept 05: Step 1 Create Client ID & Secret
    • Concept 06: Step 2 Create anti forgery state token
    • Concept 07: Step 3 Create login page
    • Concept 08: Step 4 Make a Callback Method
    • Concept 09: Step 5 GConnect
    • Concept 10: Step 6 Disconnect
    • Concept 11: Step 7 Protecting Pages
    • Concept 12: Wrap-up
  • Lesson 03: Local Permission System

    Use a local permission system to protect pages based on each user, not just whether that user is logged in.

    • Concept 01: Lesson 3 Introduction
    • Concept 02: Implementing a Local Permission System
    • Concept 03: Updating the User Model
    • Concept 04: Creating a New User
    • Concept 05: Obtaining Credentials of an Existing User
    • Concept 06: Protect Menu Pages
    • Concept 07: Wrap-Up Lesson 3
  • Lesson 04: Adding Facebook and other providers

    Discover additional OAuth providers and add Facebook authentication in your application, giving more choices for third-party auth.

    • Concept 01: Adding Additional OAuth Providers
    • Concept 02: Registering your App with Facebook
    • Concept 03: Client-Side Login with Facebook SDK
    • Concept 04: Updating login.html
    • Concept 05: Update project.py (part I)
    • Concept 06: Update project.py (part II)
    • Concept 07: Updating project.py Code
    • Concept 08: Exploring other OAuth2.0 Providers
    • Concept 09: Outro
• Module 05: Project: Item Catalog
  • Lesson 01: Build an Item Catalog

    You will develop an application that provides a list of items within a variety of categories as well as provide a user registration and authentication system. Registered users will have the ability to post, edit and delete their own items.

    Project Description - Build an Item Catalog Application

    Project Rubric - Build an Item Catalog Application

    • Concept 01: Project Overview
    • Concept 02: Project Display Example
    • Concept 03: Project Details

Part 05 (Career): Career: Networking

Networking is a very important component to a successful job search. In the following lesson, you will learn how tell your unique story to recruiters in a succinct and professional but relatable way.

• Module 01: Develop Your Personal Brand
  • Lesson 01: Develop Your Personal Brand

    In this lesson, learn how to tell your unique story in a succinct and professional way. Communicate to employers that you know how to solve problems, overcome challenges, and achieve results.

    • Concept 01: Why Network?
    • Concept 02: Why Use Elevator Pitches?
    • Concept 03: Personal Branding
    • Concept 04: Meet Chris
    • Concept 05: Elevator Pitch
    • Concept 06: Pitching to a Recruiter
    • Concept 07: Use Your Elevator Pitch
    • Concept 08: Resources in Your Career Portal
  • Lesson 02: LinkedIn Review

    Optimize your LinkedIn profile to show up in recruiter searches, build your network, and attract employers. Learn to read your LinkedIn profile through the lens of a recruiter or hiring manager.

    Project Description - LinkedIn Profile Review Project

    Project Rubric - LinkedIn Profile Review Project

    • Concept 01: Using LinkedIn
    • Concept 02: Resources in Your Career Portal
  • Lesson 03: Udacity Professional Profile

    Update and personalize your Udacity Professional Profile as you complete your Nanodegree program, and make your Profile visible to Udacity hiring partners when you’re ready to start your job search.

    Project Description - Udacity Professional Profile Review

    Project Rubric - Udacity Professional Profile Review

    • Concept 01: Introduction
    • Concept 02: Getting Started
    • Concept 03: Customizing Your Profile
    • Concept 04: Top Section
    • Concept 05: Recruitment Data
    • Concept 06: Skills
    • Concept 07: Projects
    • Concept 08: Experience
    • Concept 09: Resources in Your Career Portal
• Module 02: GitHub Profile Review
  • Lesson 01: GitHub Review

    Review how your GitHub profile, projects, and code represent you as a potential job candidate. Learn to assess your GitHub profile through the eyes of a recruiter or hiring manager.

    Project Description - Optimize Your GitHub Profile

    Project Rubric - Optimize Your GitHub Profile

    • Concept 01: Introduction
    • Concept 02: GitHub profile important items
    • Concept 03: Good GitHub repository
    • Concept 04: Interview with Art - Part 1
    • Concept 05: Identify fixes for example “bad” profile
    • Concept 06: Quick Fixes #1
    • Concept 07: Quick Fixes #2
    • Concept 08: Writing READMEs with Walter
    • Concept 09: Interview with Art - Part 2
    • Concept 10: Commit messages best practices
    • Concept 11: Reflect on your commit messages
    • Concept 12: Participating in open source projects
    • Concept 13: Interview with Art - Part 3
    • Concept 14: Participating in open source projects 2
    • Concept 15: Starring interesting repositories
    • Concept 16: Outro
    • Concept 17: Resources in Your Career Portal

Part 06 : The Frontend: JavaScript & AJAX

Extend the power of the web frontend using JavaScript, JQuery, and AJAX to build advanced interactive web applications.

• Module 01: Intro to AJAX
  • Lesson 01: Requests and APIs

    Learn how to request data from third party APIs using jQuery's AJAX functions. Examine AJAX queries in live applications and investigate APIs you can use in your own!

    • Concept 01: Pre-Introduction
    • Concept 02: Intro
    • Concept 03: Client Server Demonstration
    • Concept 04: AJAX Definition
    • Concept 05: Asynchronous vs Synchronous Requests
    • Concept 06: Facebook Example 1
    • Concept 07: Facebook Example 2
    • Concept 08: Facebook's AJAX Request
    • Concept 09: Twitter Quiz
    • Concept 10: Necessary components of an AJAX request
    • Concept 11: API Inspiration
    • Concept 12: Finding Examples of API Use
    • Concept 13: API Brainstorm
    • Concept 14: Download the Project
  • Lesson 02: Building the Move Planner App

    Follow along as Cameron uses The New York Times API to build a moving planner app. Learn how to handle errors and how to debug your AJAX methods.

    • Concept 01: Requests with jQuery
    • Concept 02: Loading Streetview
    • Concept 03: NYT API Key
    • Concept 04: NYT Implementation
    • Concept 05: Error Handling with NY Times
    • Concept 06: CORS
    • Concept 07: Wikipedia API
    • Concept 08: Error Handling with JSON P
    • Concept 09: Debugging
    • Concept 10: Speeding up the First Render
    • Concept 11: Finish
• Module 02: JavaScript Design Patterns
  • Lesson 01: Changing Expectations

    Learn why well-structured code is vitally important to a web app's structure, especially as the app gets larger. Explore how you can use MV* organizational framework to create cleaner projects.

    • Concept 01: Welcome
    • Concept 02: Introduce Cat Clicker and Andy
    • Concept 03: Cat Clicker Requirements
    • Concept 04: Reflections
    • Concept 05: Andy's Reflections
    • Concept 06: Requirements Change All The Time
    • Concept 07: First Requirements Change
    • Concept 08: Cat Clicker Requirements 2
    • Concept 09: Reflections 2
    • Concept 10: Andy's Reflections 2
    • Concept 11: Closures and Event Listeners
    • Concept 12: Second Requirements Change
    • Concept 13: Cat Clicker Premium Requirements
    • Concept 14: Reflections 3
    • Concept 15: Andy's Reflections 3
    • Concept 16: Spaghetti Code Story Time
    • Concept 17: What is Spaghetti Code
    • Concept 18: Introduction to MVO
    • Concept 19: Model Quiz
    • Concept 20: View Quiz
    • Concept 21: What Is the Model in Our Code
    • Concept 22: What Is the View in Our Code
    • Concept 23: What Is the Octopus in Our Code
    • Concept 24: Identify the MVO in New App
    • Concept 25: Explore The App's Structure
    • Concept 26: Where Should This Feature Live?
    • Concept 27: Implement Note Date
    • Concept 28: Segue Into L2
  • Lesson 02: Refactoring with Separation of Concerns

    Begin refactoring your Cat Clicker code and learn the best ways to improve its structure.

    • Concept 01: Introduction to Lesson 2
    • Concept 02: Identify Model and View
    • Concept 03: Review Model and View for CC Premium
    • Concept 04: Identify Octopus
    • Concept 05: Andy’s Code 1
    • Concept 06: Andy’s Code 2
    • Concept 07: In Defense of Andy
    • Concept 08: Rebuild Cat Clicker Premium
    • Concept 09: Cat Clicker Premium Specs
    • Concept 10: Cat Clicker Premium Solution
    • Concept 11: Cat Clicker Premium Solution Review
    • Concept 12: Cat Clicker Premium Pro
    • Concept 13: Cat Clicker Premium Pro Specs
    • Concept 14: How to Modernize Projects
    • Concept 15: Interview with Nic
    • Concept 16: Interview with Jacques
    • Concept 17: Refactor Spaghetti Code
    • Concept 18: Repository for Attendance App
    • Concept 19: What Method Did You Use?
    • Concept 20: Interview With The Author
    • Concept 21: Refactoring the Resumé
    • Concept 22: Repository Information for Resume
    • Concept 23: Segue Into L3
  • Lesson 03: Using an Organization Library

    Learn about MV* frameworks like KnockoutJS to improve your Cat Clicker Application.

    • Concept 01: MVO in the wild
    • Concept 02: Library vs Framework 1
    • Concept 03: Library vs Framework 2
    • Concept 04: Interview with Nic About Using Libraries
    • Concept 05: Universal Organizational Concepts
    • Concept 06: What Does Knockout Give Us
    • Concept 07: Bindings and Views in Knockout
    • Concept 08: Knockout Views Quiz
    • Concept 09: Models in Knockout
    • Concept 10: Knockout Models Quiz
    • Concept 11: Interview about Documentation
    • Concept 12: Smarter Arrays
    • Concept 13: Smart Models Work Differently
    • Concept 14: Benefits of Smart Models
    • Concept 15: Similarities between jQuery and KnockOut
    • Concept 16: Building Something with Knockout
    • Concept 17: Cat Clicker HTML and Bindings
    • Concept 18: Computed Observables
    • Concept 19: Computed Observables Quiz
    • Concept 20: Review of Terms
    • Concept 21: Computed Observables in Practice
    • Concept 22: Add Cat Levels to Cat Clicker
    • Concept 23: Show Cats With Control Structures
    • Concept 24: Separating Out the Model
    • Concept 25: 'with' and Binding Contexts
    • Concept 26: How I Implemented "With"
    • Concept 27: Getting Ready To Add More Cats
    • Concept 28: Adding More Cats
  • Lesson 04: Learning a New Codebase

    Learn how to work with new codebases and gain familiarity with the popular BackboneJS Framework.

    • Concept 01: Interview: Gaining Context
    • Concept 02: What's Next
    • Concept 03: Exploring a New Codebase
    • Concept 04: Codebase Quiz
    • Concept 05: Getting the Big Picture of our Library
    • Concept 06: Interview: Be Tofu
    • Concept 07: Exploring a Codebase
    • Concept 08: Modifying a Feature
    • Concept 09: Adding Additional UI
    • Concept 10: Adding a New Feature
    • Concept 11: More Ideas
• Module 03: Google Maps APIs
  • Lesson 01: Getting Started with the APIs

    Set up your developer credentials and get started with the Google Maps APIs.

    • Concept 01: Intro
    • Concept 02: Your Project
    • Concept 03: Your API Key
    • Concept 04: The JavaScript API Overview
    • Concept 05: Hello Map
    • Concept 06: Making your Mark
    • Concept 07: Window Shopping Part 1
    • Concept 08: Window Shopping Part 2
    • Concept 09: Markers Infowindows
    • Concept 10: Being Stylish
    • Concept 11: Styles
    • Concept 12: Static Maps and Street View Imagery
    • Concept 13: Imagery
    • Concept 14: Pitch and Heading
    • Concept 15: Library Cards
    • Concept 16: Geometry and Visualization
    • Concept 17: Drawing
    • Concept 18: Drawing and Geometry
  • Lesson 02: Understanding API Services

    Explore the location services available in the Google Maps APIs, including the Geocoding, Elevation, and Directions APIs.

    • Concept 01: Web Services and Geocoding Part 1
    • Concept 02: Web Services and Geocoding Part 2
    • Concept 03: Geocoding Requests and Responses
    • Concept 04: Status
    • Concept 05: Geocoding Requests and Responses
    • Concept 06: Geocoding in the App
    • Concept 07: Interpreting Geocoding Responses
    • Concept 08: No Mountain High Enough - Elevation API
    • Concept 09: My Commute - Distance Matrix API Part 1
    • Concept 10: My Commute - Distance Matrix API Part 2
    • Concept 11: I want to ride my bicycle
    • Concept 12: My Commute - Directions API
    • Concept 13: Displaying Routes Directions Service
    • Concept 14: From me to you
    • Concept 15: Distance Matrix and Directions Specifics
    • Concept 16: The Long and Winding Roads Roads API
    • Concept 17: The Roads Less Travelled
    • Concept 18: Speed Limits Request
    • Concept 19: Roads API
    • Concept 20: Faster is Better - Place Autocomplete 1
    • Concept 21: Faster is Better - Place Autocomplete 2
    • Concept 22: Devil in the Details - Places Details
    • Concept 23: Places I Remember
    • Concept 24: Here, There, and Everywhere
    • Concept 25: Across the Universe TimeZone API
    • Concept 26: Time after Time
    • Concept 27: I am here, oh wait, where am I?
    • Concept 28: The Journey so Far
  • Lesson 03: Using the APIs in Practice

    Learn the practical details you need to know to use the Google Maps APIs in the real world.

    • Concept 01: Your Google Developer Project
    • Concept 02: Premium Plan Specifics
    • Concept 03: Developer Documentation
    • Concept 04: Project Description
    • Concept 05: Feedback
  • Lesson 04: Neighborhood Map

    You will develop a single-page application featuring a map of your neighborhood or a neighborhood you would like to visit. You will then add additional functionality to this application, including: map markers to identify popular locations or places you'd like to visit, a search function to easily discover these locations, and a listview to support simple browsing of all locations. You will then research and implement third-party APIs that provide additional information about each of these locations (such as StreetView images, Wikipedia articles, Yelp reviews, etc).

    Project Description - Neighborhood Map

    Project Rubric - Neighborhood Map

    • Concept 01: Project Overview
    • Concept 02: Project Details
    • Concept 03: A Note About Plagiarism

Part 07 (Career): Career: Full Stack Interview Practice

Now that you've practiced your skills through your project work, learn how you can present your knowledge in an interview.

• Module 01: Interview Practice (Full Stack)
  • Lesson 01: Ace Your Interview

    Learn strategies to prepare yourself for an interview.

    • Concept 01: Introduction
    • Concept 02: Interviews are Conversations
    • Concept 03: STAR Method
  • Lesson 02: Practice Behavioral Questions

    Practice answering behavioral questions and evaluate sample responses.

    • Concept 01: Introduction
    • Concept 02: Self-Practice: Behavioral Questions
    • Concept 03: Analyzing Behavioral Answers
    • Concept 04: Time When You Showed Initiative?
    • Concept 05: What Motivates You at the Workplace?
    • Concept 06: A Problem and How You Dealt With It?
    • Concept 07: What Do You Know About the Company?
    • Concept 08: Time When You Dealt With Failure?
  • Lesson 03: Interview Fails

    Some real-life examples of interviews that didn't go as expected - it happens all the time!

    • Concept 01: Interview Fails
    • Concept 02: Interviewing Fails: Mike Wales
    • Concept 03: Interviewing Fails: Siya Raj Purohit
    • Concept 04: Interviewing Fails: Lyla Fujiwara
  • Lesson 04: Land a Job Offer

    You've practiced a lot for the interview by now. Continue practicing, and you'll ace the interview!

    • Concept 01: Land a Job Offer
  • Lesson 05: Interview Practice

    Walk through an example Full Stack interview and find out how you can improve!

    Project Description - Interview Practice (Full Stack)

    Project Rubric - Interview Practice (Full Stack)

    • Concept 01: Analyzing an Interview
    • Concept 02: Is it a Palindrome?
    • Concept 03: What happens when you go to google.com?
    • Concept 04: Describe an xsrf attack
    • Concept 05: Find 2 elements that add up to K
    • Concept 06: Overall Feedback
    • Concept 07: Keep Practicing!
    • Concept 08: Resources in Your Career Portal
• Module 02: Data Structures & Algorithms with Python
  • Lesson 01: Introduction and Efficiency

    Begin the section on data structures and algorithms, including Python and efficiency practice.

    • Concept 01: Course Introduction
    • Concept 02: Course Outline
    • Concept 03: Course Expectations
    • Concept 04: Syntax
    • Concept 05: Python Practice
    • Concept 06: Python: The Basics
    • Concept 07: Efficiency
    • Concept 08: Notation Intro
    • Concept 09: Notation Continued
    • Concept 10: Worst Case and Approximation
    • Concept 11: Efficiency Practice
  • Lesson 02: List-Based Collections

    Learn the definition of a list in computer science, and see definitions and examples of list-based data structures, arrays, linked lists, stacks, and queues.

    • Concept 01: Welcome to Collections
    • Concept 02: Lists
    • Concept 03: Arrays
    • Concept 04: Python Lists
    • Concept 05: Linked Lists
    • Concept 06: Linked Lists in Depth
    • Concept 07: Linked List Practice
    • Concept 08: Stacks
    • Concept 09: Stacks Details
    • Concept 10: Stack Practice
    • Concept 11: Queues
    • Concept 12: Queue Practice
  • Lesson 03: Searching and Sorting

    Explore how to search and sort with list-based data structures, including binary search and bubble, merge, and quick sort. Learn how to use recursion.

    • Concept 01: Binary Search
    • Concept 02: Efficiency of Binary Search
    • Concept 03: Binary Search Practice
    • Concept 04: Recursion
    • Concept 05: Recursion Practice
    • Concept 06: Intro to Sorting
    • Concept 07: Bubble Sort
    • Concept 08: Efficiency of Bubble Sort
    • Concept 09: Bubble Sort Practice
    • Concept 10: Merge Sort
    • Concept 11: Efficiency of Merge Sort
    • Concept 12: Merge Sort Practice
    • Concept 13: Quick Sort
    • Concept 14: Efficiency of Quick Sort
    • Concept 15: Quick Sort Practice
  • Lesson 04: Maps and Hashing

    Understand the concepts of sets, maps (dictionaries), and hashing. Examine common problems and approaches to hashing, and practice with examples.

    • Concept 01: Introduction to Maps
    • Concept 02: Sets and Maps
    • Concept 03: Python Dictionaries
    • Concept 04: Introduction to Hashing
    • Concept 05: Hashing
    • Concept 06: Collisions
    • Concept 07: Load Factor
    • Concept 08: Hash Maps
    • Concept 09: String Keys
    • Concept 10: String Keys Practice
  • Lesson 05: Trees

    Learn the concepts and terminology associated with tree data structures. Investigate tree types, such as binary search trees, heaps, and self-balancing trees.

    • Concept 01: Trees
    • Concept 02: Tree Basics
    • Concept 03: Tree Terminology
    • Concept 04: Tree Practice
    • Concept 05: Tree Traversal
    • Concept 06: Depth-First Traversals
    • Concept 07: Tree Traversal Practice
    • Concept 08: Search and Delete
    • Concept 09: Insert
    • Concept 10: Binary Search Trees
    • Concept 11: Binary Tree Practice
    • Concept 12: BSTs
    • Concept 13: BST Complications
    • Concept 14: BST Practice
    • Concept 15: Heaps
    • Concept 16: Heapify
    • Concept 17: Heap Implementation
    • Concept 18: Self-Balancing Trees
    • Concept 19: Red-Black Trees - Insertion
    • Concept 20: Tree Rotations
  • Lesson 06: Graphs

    Examine the theoretical concept of a graph and understand common graph terms, coded representations, properties, traversals, and paths.

    • Concept 01: Graph Introduction
    • Concept 02: What Is a Graph?
    • Concept 03: Directions and Cycles
    • Concept 04: Connectivity
    • Concept 05: Graph Practice
    • Concept 06: Graph Representations
    • Concept 07: Adjacency Matrices
    • Concept 08: Graph Representation Practice
    • Concept 09: Graph Traversal
    • Concept 10: DFS
    • Concept 11: BFS
    • Concept 12: Graph Traversal Practice
    • Concept 13: Eulerian Path
  • Lesson 07: Case Studies in Algorithms

    Explore famous computer science problems, specifically the Shortest Path Problem, the Knapsack Problem, and the Traveling Salesman Problem.

    • Concept 01: Case Study Introduction
    • Concept 02: Shortest Path Problem
    • Concept 03: Dijkstra's Algorithm
    • Concept 04: Knapsack Problem
    • Concept 05: A Faster Algorithm
    • Concept 06: Dynamic Programming
    • Concept 07: Traveling Salesman Problem
    • Concept 08: Exact and Approximate Algorithms
  • Lesson 08: Technical Interview - Python

    Practice with five technical interviewing questions on topics discussed in the data structures and algorithms course and get a personalized review on both your code and solutions.

    Project Description - Technical Interview Practice

    Project Rubric - Technical Interview Practice

    • Concept 01: Interview Introduction
    • Concept 02: Clarifying the Question
    • Concept 03: Confirming Inputs
    • Concept 04: Test Cases
    • Concept 05: Brainstorming
    • Concept 06: Runtime Analysis
    • Concept 07: Coding
    • Concept 08: Coding 2
    • Concept 09: Debugging
    • Concept 10: Interview Wrap-Up
    • Concept 11: Time for Live Practice with Pramp
    • Concept 12: Next Steps
    • Concept 13: Resources in Your Career Portal
    • Concept 14: Project Description

Part 08 : Deploying to Linux Servers

You will take a baseline installation of a Linux distribution on a virtual machine and prepare it to host your web applications, to include installing updates, securing it from a number of attack vectors and installing/configuring web and database servers.

Note: If you have no experience working in the shell we recommend starting with Linux Command Line Basics. Otherwise, you can jump straight into Configuring Linux Web Servers.

• Module 01: Linux Command Line Basics
  • Lesson 01: Get Into the Shell

    Get started using a terminal! Learn how to enter commands in the shell and interpret their output.

    • Concept 01: About This Course
    • Concept 02: What's a Virtual Machine
    • Concept 03: Setting Up Your Own (Virtual) Linux Box
    • Concept 04: Log In and Break Stuff
    • Concept 05: In the VM or out of the VM?
    • Concept 06: Commands That Work
    • Concept 07: What can you do in the terminal?
    • Concept 08: The Terminal Interface
    • Concept 09: The Terminal vs The Shell
    • Concept 10: Try More Commands
    • Concept 11: What is a Shell Command Anyway
    • Concept 12: Reading the Output of a Command
    • Concept 13: Identify User Input
    • Concept 14: Lesson Outro
  • Lesson 02: Shell Commands

    Explore common shell commands and, more importantly, learn how to use the Unix manual to learn more!

    • Concept 01: L2 Intro
    • Concept 02: Filenames and Contents
    • Concept 03: Command History
    • Concept 04: Some Common Commands
    • Concept 05: Manual Pages
    • Concept 06: Manual Pages and cowsay
    • Concept 07: Using the Manual for Serious Purpose
    • Concept 08: Options to ls
    • Concept 09: Researching Commands
    • Concept 10: Line Based Programs
    • Concept 11: Waiting for Input
    • Concept 12: Full Screen Interactive Programs: less
    • Concept 13: Editing Files in nano
    • Concept 14: Lesson Outro
  • Lesson 03: The Linux Filesystem

    Learn how the Linux filesystem is organized. Navigate directories and organize files from shell commands.

    • Concept 01: Intro to the Filesystem
    • Concept 02: The Filesystem Tree
    • Concept 03: The Working Directory
    • Concept 04: Absolute and Relative Paths
    • Concept 05: Absolute and Relative Paths
    • Concept 06: cd without args
    • Concept 07: cd to not a directory
    • Concept 08: Navigating Directories
    • Concept 09: Tab Completion
    • Concept 10: Moving and Copying Files
    • Concept 11: Making and Removing Directories
    • Concept 12: mv and directories
    • Concept 13: Globbing
    • Concept 14: Globbing Quiz
    • Concept 15: Applying Globbing
    • Concept 16: Course Outro
• Module 02: Configuring Linux Web Servers
  • Lesson 01: Intro to Linux

    Gain an understanding of the Linux operating system and how it differs from other operating systems you may have experienced in the past.

    • Concept 01: Introduction
    • Concept 02: What is Linux
    • Concept 03: Free as in Beer
    • Concept 04: Intro to Distributions
    • Concept 05: Getting Started with Vagrant
    • Concept 06: Linux Distribution Comparison
    • Concept 07: Vagrant Commands
    • Concept 08: This is Not Your Computer
    • Concept 09: Where are we
    • Concept 10: Your Home Directory
    • Concept 11: Users Home Directory
    • Concept 12: Other Important Directories
    • Concept 13: Traversing the File System
    • Concept 14: Understanding $PATH
    • Concept 15: Outro
  • Lesson 02: Linux Security

    Dive deep into Linux Security to ensure your service remains stable and free from attackers.

    • Concept 01: Intro to Linux Security
    • Concept 02: The Rule of Least Privilege
    • Concept 03: Becoming a Super User
    • Concept 04: sudo vs. su
    • Concept 05: Package Source Lists
    • Concept 06: Updating Available Package Lists
    • Concept 07: Upgrading Installed Packages
    • Concept 08: Other Package Related Tasks
    • Concept 09: Discovering Packages
    • Concept 10: Using Package Search
    • Concept 11: Using Finger
    • Concept 12: Introduction to /etc/passwd
    • Concept 13: Reading /etc/passwd Entries
    • Concept 14: User Account Info
    • Concept 15: Introduction to User Management
    • Concept 16: Creating a New User
    • Concept 17: Connecting as the New User
    • Concept 18: Introduction to etc sudoers
    • Concept 19: Giving Sudo Access
    • Concept 20: Resetting Passwords
    • Concept 21: Another Authentication Method
    • Concept 22: Public Key Encryption
    • Concept 23: Generating Key Pairs
    • Concept 24: Supported Key Types
    • Concept 25: Installing a Public Key
    • Concept 26: Forcing Key Based Authentication
    • Concept 27: Introduction to File Permissions
    • Concept 28: Owners and Groups
    • Concept 29: Identifying Owners and Groups
    • Concept 30: Octal Permissions [missing dialogue]
    • Concept 31: Octal File Permissions
    • Concept 32: chgrp and chown
    • Concept 33: Intro to Ports
    • Concept 34: Default Ports for Popular Services
    • Concept 35: Intro to Firewalls
    • Concept 36: Intro to UFW
    • Concept 37: Configuring Ports in UFW
    • Concept 38: Conclusion
  • Lesson 03: Web Application Servers

    Install all of the required software to turn your Linux server into a full-fledged web application server and host your very own application!

    • Concept 01: Introduction
    • Concept 02: Vagrant Prerequisites
    • Concept 03: Installing Apache
    • Concept 04: Installing mod_wsgi
    • Concept 05: Your First WSGI Application
    • Concept 06: Installing PostgreSQL
• Module 03: Project: Linux Server Configuration
  • Lesson 01: Linux Server Configuration

    You will take a baseline installation of a Linux distribution on a virtual machine and prepare it to host your web applications.

    Project Description - Linux Server Configuration

    Project Rubric - Linux Server Configuration

    • Concept 01: Project Overview
    • Concept 02: Project Details
    • Concept 03: Get started on Lightsail
    • Concept 04: Linux Server Configuration Webcasts

Part 09 (Elective): Elective Course: JavaScript Basics

• Module 01: JavaScript Basics
  • Lesson 01: Getting Up and Running

    Meet your next assignment: The Online Resume project. While building this project, you'll learn the importance of the browser's console.log as well as a brief intro to the popular JavaScript library, jQuery.

    • Concept 01: Welcome to the Course!
    • Concept 02: Resume Introduction
    • Concept 03: Your Goals
    • Concept 04: The GitHub Repo
    • Concept 05: Download the GH Repo
    • Concept 06: A Note about HTML
    • Concept 07: The Resume's HTML
    • Concept 08: CSS and JS in the Resume
    • Concept 09: The Browser JavaScript Console
    • Concept 10: console.log()
    • Concept 11: Hacking Udacity's Front Page
    • Concept 12: Using .append() to Build a Page
    • Concept 13: Try .append() for Yourself
    • Concept 14: Technologies and Techniques Quiz
  • Lesson 02: Data Types

    Learn to represent real world data using JavaScript. You'll gain experience working with strings, booleans, arrays, objects, and JSON data structures.

    • Concept 01: var loveJS = true;
    • Concept 02: Save and .append() Data
    • Concept 03: string.replace()
    • Concept 04: Mixing .replace() and .append()
    • Concept 05: Format Data, Build a Resume Header
    • Concept 06: String Manipulation Quiz 1
    • Concept 07: String Manipulation Quiz 1 Solution
    • Concept 08: Truthy/Falsy
    • Concept 09: var quiz = true;
    • Concept 10: Arrays
    • Concept 11: .append()ing Arrays Quiz
    • Concept 12: Array Manipulation
    • Concept 13: String Manipulation Quiz 2
    • Concept 14: Object Literal Notation
    • Concept 15: Biography Quiz
    • Concept 16: Dot and Bracket Notation
    • Concept 17: Practice with Objects
    • Concept 18: A Note about JSON
    • Concept 19: JSON
    • Concept 20: Validating JSON
    • Concept 21: Validating JSON Quiz
    • Concept 22: All the Resume Sections
  • Lesson 03: Flow Control

    Use JavaScript's flow-control structures — if statements, while loops, and for loops — to build more complex functionality.

    • Concept 01: If Statements
    • Concept 02: While Loops
    • Concept 03: For Loops
    • Concept 04: For-In Loops
    • Concept 05: Work!
    • Concept 06: A Note About For-In Loops
    • Concept 07: Functions
    • Concept 08: Click Metrics
    • Concept 09: Collecting Click Locations
    • Concept 10: Return Statements
    • Concept 11: Internationalize Names
    • Concept 12: Encapsulation
    • Concept 13: Encapsulating Functions
    • Concept 14: Independent Research
    • Concept 15: Customize the Portfolio
    • Concept 16: The Final Project!

Part 10 (Elective): Elective Course: Intro to JavaScript

• Module 01: Intro to JavaScript
  • Lesson 01: What is JavaScript?

    Learn the history of JavaScript and start writing your code immediately using the JavaScript console.

    • Concept 01: Intro to JavaScript
    • Concept 02: History of JavaScript
    • Concept 03: The JavaScript Console
    • Concept 04: Developer Tools on Different Browsers
    • Concept 05: console.log
    • Concept 06: JavaScript Demo
    • Concept 07: Lesson 1 Summary
  • Lesson 02: Data Types & Variables

    Learn to represent real-world data using JavaScript variables, and distinguish between the different data types in the language.

    • Concept 01: Intro to Data Types
    • Concept 02: Numbers
    • Concept 03: Comments
    • Concept 04: Quiz: First Expression (2-1)
    • Concept 05: Strings
    • Concept 06: String Concatenation
    • Concept 07: Variables
    • Concept 08: Quiz: Converting Temperatures (2-2)
    • Concept 09: String Index
    • Concept 10: Escaping Strings
    • Concept 11: Comparing Strings
    • Concept 12: Quiz: Favorite Food (2-3)
    • Concept 13: Quiz: String Equality for All (2-4)
    • Concept 14: Quiz: All Tied Up (2-5)
    • Concept 15: Quiz: Yosa Buson (2-6)
    • Concept 16: Booleans
    • Concept 17: Quiz: Facebook Post (2-7)
    • Concept 18: Null, Undefined, and NaN
    • Concept 19: Equality
    • Concept 20: Quiz: Semicolons! (2-8)
    • Concept 21: Quiz: What's my Name? (2-9)
    • Concept 22: Quiz: Out to Dinner (2-10)
    • Concept 23: Quiz: Mad Libs (2-11)
    • Concept 24: Quiz: One Awesome Message (2-12)
    • Concept 25: Lesson 2 Summary
  • Lesson 03: Conditionals

    Learn how to add logic to your JavaScript programs using conditional statements.

    • Concept 01: Intro to Conditionals
    • Concept 02: Quiz: Flowcharts (3-1)
    • Concept 03: Flowchart to Code
    • Concept 04: If...Else Statements
    • Concept 05: Else If Statements
    • Concept 06: Quiz: Even or Odd (3-2)
    • Concept 07: Quiz: Musical Groups (3-3)
    • Concept 08: Quiz: Murder Mystery (3-4)
    • Concept 09: More Complex Problems
    • Concept 10: Logical Operators
    • Concept 11: Logical AND and OR
    • Concept 12: Quiz: Checking your Balance (3-5)
    • Concept 13: Quiz: Ice Cream (3-6)
    • Concept 14: Quiz: What do I Wear? (3-7)
    • Concept 15: Advanced Conditionals
    • Concept 16: Truthy and Falsy
    • Concept 17: Ternary Operator
    • Concept 18: Quiz: Navigating the Food Chain (3-8)
    • Concept 19: Switch Statement
    • Concept 20: Falling-through
    • Concept 21: Quiz: Back to School (3-9)
    • Concept 22: Lesson 3 Summary
  • Lesson 04: Loops

    Harness the power of JavaScript loops to reduce code duplication and automate repetitive tasks.

    • Concept 01: Intro to Loops
    • Concept 02: While Loops
    • Concept 03: Parts of a While Loop
    • Concept 04: Quiz: JuliaJames (4-1)
    • Concept 05: Quiz: 99 Bottles of Juice (4-2)
    • Concept 06: Quiz: Countdown, Liftoff! (4-3)
    • Concept 07: For Loops
    • Concept 08: Parts of a For Loop
    • Concept 09: Nested Loops
    • Concept 10: Increment and Decrement
    • Concept 11: Quiz: Changing the Loop (4-4)
    • Concept 12: Quiz: Fix the Error 1 (4-5)
    • Concept 13: Quiz: Fix the Error 2 (4-6)
    • Concept 14: Quiz: Factorials! (4-7)
    • Concept 15: Quiz: Find my Seat (4-8)
    • Concept 16: Lesson 4 Summary
  • Lesson 05: Functions

    Dive into the world of JavaScript functions. Learn to harness their power to streamline and organize your programs.

    • Concept 01: Intro to Functions
    • Concept 02: Function Example
    • Concept 03: Declaring Functions
    • Concept 04: Function Recap
    • Concept 05: Quiz: Laugh it Off 1 (5-1)
    • Concept 06: Quiz: Laugh it Off 2 (5-2)
    • Concept 07: Return Values
    • Concept 08: Using Return Values
    • Concept 09: Scope
    • Concept 10: Scope Example
    • Concept 11: Shadowing
    • Concept 12: Global Variables
    • Concept 13: Scope Recap
    • Concept 14: Hoisting
    • Concept 15: Hoisting Recap
    • Concept 16: Quiz: Build a Triangle (5-3)
    • Concept 17: Function Expressions
    • Concept 18: Patterns with Function Expressions
    • Concept 19: Function Expression Recap
    • Concept 20: Quiz: Laugh (5-4)
    • Concept 21: Quiz: Cry (5-5)
    • Concept 22: Quiz: Inline (5-6)
    • Concept 23: Lesson 5 Summary
  • Lesson 06: Arrays

    Learn how to use Arrays to store complex data in your JavaScript programs.

    • Concept 01: Intro to Arrays
    • Concept 02: Donuts to Code
    • Concept 03: Creating an Array
    • Concept 04: Accessing Array Elements
    • Concept 05: Array Index
    • Concept 06: Quiz: UdaciFamily (6-1)
    • Concept 07: Quiz: Building the Crew (6-2)
    • Concept 08: Quiz: The Price is Right (6-3)
    • Concept 09: Array Properties and Methods
    • Concept 10: Length
    • Concept 11: Push
    • Concept 12: Pop
    • Concept 13: Splice
    • Concept 14: Quiz: Colors of the Rainbow (6-4)
    • Concept 15: Quiz: Quidditch Cup (6-5)
    • Concept 16: Quiz: Joining the Crew (6-6)
    • Concept 17: Quiz: Checking out the Docs (6-7)
    • Concept 18: Array Loops
    • Concept 19: The forEach Loop
    • Concept 20: Quiz: Another Type of Loop (6-8)
    • Concept 21: Map
    • Concept 22: Quiz: I Got Bills (6-9)
    • Concept 23: Arrays in Arrays
    • Concept 24: 2D Donut Arrays
    • Concept 25: Quiz: Nested Numbers (6-10)
    • Concept 26: Lesson 6 Summary
  • Lesson 07: Objects

    Meet the next JavaScript data structure: the Object. Learn to use it to store complex data alongside Arrays.

    • Concept 01: Intro to Objects
    • Concept 02: Objects in Code
    • Concept 03: Quiz: Umbrella (7-1)
    • Concept 04: Objects
    • Concept 05: Object Literals
    • Concept 06: Naming Conventions
    • Concept 07: Summary of Objects
    • Concept 08: Quiz: Menu Items (7-2)
    • Concept 09: Quiz: Bank Accounts 1 (7-3)
    • Concept 10: Quiz: Bank Accounts 2 (7-4)
    • Concept 11: Quiz: Facebook Friends (7-5)
    • Concept 12: Quiz: Donuts Revisited (7-6)
    • Concept 13: Lesson 7 Summary

Part 11 (Elective): Elective Course: Networking for Web Developers

How does the Web work? Under the hood of HTTP there's a whole stack of networking protocols.

Explore the underpinnings of the net with tools like traceroute, tcpdump, and nc.

• Module 01: Networking
  • Lesson 01: From Ping to HTTP

    Start exploring the network using low-level command-line tools such as ping and netcat.

    • Concept 01: Intro
    • Concept 02: Setting Up For This Course
    • Concept 03: Try some network things!
    • Concept 04: ping 8.8.8.8
    • Concept 05: Ping versus HTTP
    • Concept 06: Write your own HTTP to Wikipedia
    • Concept 07: printf and netcat
    • Concept 08: What web server does Google use?
    • Concept 09: printf and netcat illustrate layers
    • Concept 10: Listen on a Port
    • Concept 11: Waiting For Your Call
    • Concept 12: Listening and Connecting
    • Concept 13: Experiment with nc and HTTP
    • Concept 14: Port Numbers
    • Concept 15: Port Numbers Part Two
    • Concept 16: One listening server per port
    • Concept 17: Be a Web Server
    • Concept 18: Outro
  • Lesson 02: Names and Addresses

    Investigate the Domain Name System (DNS), which translates hostnames into IP addresses.

    • Concept 01: Intro
    • Concept 02: Ping a Hostname
    • Concept 03: Intro to DNS
    • Concept 04: The host command
    • Concept 05: Dig into DNS Records
    • Concept 06: Research DNS Record Types
    • Concept 07: DNS is Distributed with Caching
    • Concept 08: DNS and HTTP
    • Concept 09: Subdomains and FQDNs
    • Concept 10: Register a Domain
    • Concept 11: 32 bits to 128 bits
    • Concept 12: 8 Bits in a Byte
    • Concept 13: Bits
    • Concept 14: Bits in a Port Number
    • Concept 15: Outro
  • Lesson 03: Addressing and Networks

    Investigate the structure and use of Internet addresses, including network blocks, interfaces, network address translation (NAT), and IPv6.

    • Concept 01: Intro
    • Concept 02: Special Addresses
    • Concept 03: Reserved IP addresses
    • Concept 04: How Many Addresses
    • Concept 05: Netblocks and Subnets
    • Concept 06: Subnet Masks
    • Concept 07: Stanford's /14
    • Concept 08: Not Enough Addresses
    • Concept 09: The Host is a Lie
    • Concept 10: Interfaces Quiz
    • Concept 11: Routers and Default Gateways
    • Concept 12: Default Gateway Quiz
    • Concept 13: NAT
    • Concept 14: Private and Public
    • Concept 15: IPv6
    • Concept 16: IPv6 Quiz
    • Concept 17: Outro
  • Lesson 04: Protocol Layers

    Use tcpdump to examine packets that make up the requests and responses for three protocols: ping, DNS, and HTTP.

    • Concept 01: Intro: HTTP on TCP on IP
    • Concept 02: The Protocol Stack
    • Concept 03: Watching Ping and DNS in tcpdump
    • Concept 04: Watching HTTP in tcpdump
    • Concept 05: Analyzing the tcpdump data
    • Concept 06: tcpdump packet quiz
    • Concept 07: Sequence Diagrams
    • Concept 08: Connection Establishment
    • Concept 09: Buffering
    • Concept 10: TCP Flags
    • Concept 11: Why do packets drop
    • Concept 12: TCP Errors
    • Concept 13: Timeouts
    • Concept 14: Errors Quiz
    • Concept 15: Outro
  • Lesson 05: Big Networks

    Learn more about bandwidth, latency, filtering, and other properties that matter when users are accessing your application over the Internet.

    • Concept 01: Intro: Slow Sucks!
    • Concept 02: Hops: Not Just for Beer
    • Concept 03: The Story about Ping
    • Concept 04: The Story about Traceroute
    • Concept 05: Bandwidth across Networks
    • Concept 06: What is Fast Anyway
    • Concept 07: Bandwidth-Delay Product
    • Concept 08: Congestion
    • Concept 09: Middleboxes 1: Firewalls & Filtering
    • Concept 10: What can a filter do?
    • Concept 11: Middleboxes 2: Proxies & NAT
    • Concept 12: Users behind a NAT
    • Concept 13: Outro

Part 12 (Elective): Elective Course: How to Use Git & Github

• Module 01: Git and GitHub
  • Lesson 01: Navigating a Commit History

    Learn what makes Git such a useful tool for developers and dive right into working with Git commit histories using an existing project.

    • Concept 01: Introduction
    • Concept 02: Course Overview
    • Concept 03: Differences Between Two Files
    • Concept 04: Finding Diffs Between Larger Files
    • Concept 05: Reflections
    • Concept 06: Reflect: Using diff to Find Bugs
    • Concept 07: Where Do Versions Come From?
    • Concept 08: Reflect: Using History for Efficiency
    • Concept 09: Properties of a VCS for Code
    • Concept 10: Manual Commits in Git
    • Concept 11: Creating a Concept Map
    • Concept 12: Using Git to View History
    • Concept 13: Concept Map: diff
    • Concept 14: One Commit per Logical Change
    • Concept 15: Reflect: Manual Commits
    • Concept 16: Tracking Across Multiple Files
    • Concept 17: Git Commits Across Multiple Files
    • Concept 18: Reflect: Multi-File Commits
    • Concept 19: Interview with Jeffrey Middleton
    • Concept 20: Installing Git
    • Concept 21: Cloning and Exploring The Repo
    • Concept 22: Reflect: Using Git to View History
    • Concept 23: Concept Map: repository, clone, log
    • Concept 24: Git Errors and Warnings
    • Concept 25: Checking Out Old Versions of Code
    • Concept 26: Reflect: Confidence from Version Control
    • Concept 27: Interview with Lewis Kaneshiro
    • Concept 28: Git Workspace
    • Concept 29: Setting Up Your Workspace on Windows
    • Concept 30: Setting Up Your Workspace on Mac
    • Concept 31: Reflect: How Do You Want to Use Git?
    • Concept 32: Lesson 1 Summary
    • Concept 33: Survey Says!
  • Lesson 02: Creating and Modifying a Repository

    Take the next steps in learning Git: create a repository, make commits, manage branches and merges.

    • Concept 01: What Makes a Repository a Repository?
    • Concept 02: Initializing a Repository
    • Concept 03: Examining the New Repository
    • Concept 04: Reflect: Initializing a Repository
    • Concept 05: Staging Area
    • Concept 06: Concept Map: init, add, staging area
    • Concept 07: Reflect: Staging Area
    • Concept 08: Writing Good Commit Messages
    • Concept 09: Committing Changes
    • Concept 10: git diff Revisited
    • Concept 11: Commit the Bug Fix
    • Concept 12: Reflect: Commit Size
    • Concept 13: Branches
    • Concept 14: Making a Branch
    • Concept 15: Reflect: When to Use Branches
    • Concept 16: Interview with Mike Wales
    • Concept 17: Branches for Collaboration
    • Concept 18: Reachability
    • Concept 19: Detached HEAD Revisited
    • Concept 20: Reflect: Visualizing with Diagrams
    • Concept 21: Combining Simple Files
    • Concept 22: Combining Simple Files Using Original
    • Concept 23: Merging Coins into Master
    • Concept 24: Merging on the Command Line
    • Concept 25: Reflect: Merging Two Branches
    • Concept 26: Merge Conflicts
    • Concept 27: Conflict Detection
    • Concept 28: Update Easy Mode
    • Concept 29: Resolving Merge Conflicts
    • Concept 30: Committing the Conflict Resolution
    • Concept 31: Concept Map: branch, merge
    • Concept 32: Reflect: Automatic vs. Manual Merging
    • Concept 33: Interview with Jeffrey Middleton
    • Concept 34: Lesson 2 Summary
  • Lesson 03: Using GitHub to Collaborate

    Use Git along with GitHub to collaborate on codebases with multiple developers. Learn the pull request workflow for managing commits.

    • Concept 01: Lesson 3 Introduction
    • Concept 02: Intro to GitHub
    • Concept 03: Creating a GitHub Account
    • Concept 04: Keeping Repositories in Sync
    • Concept 05: Adding a Remote
    • Concept 06: Editing Files on GitHub
    • Concept 07: Reflect: When to Use a Remote Repository
    • Concept 08: Pulling Changes
    • Concept 09: Concept Map: GitHub, Push, Pull, Remote
    • Concept 10: Reflect: Manual vs. Automatic Pull
    • Concept 11: Forking a Repository
    • Concept 12: Fork the Recipes Repository
    • Concept 13: Push Changes to the Recipes Repository
    • Concept 14: Reflect: Forks, Clones, and Branches
    • Concept 15: Collaborations Cause Conflict
    • Concept 16: Change the Chili Recipe
    • Concept 17: Sarah Changes the Chili Recipe
    • Concept 18: Simulate Sarah's Changes
    • Concept 19: Updating Local Copies of Remote Branches
    • Concept 20: Merging the Changes Together
    • Concept 21: Fast-Forward Merges
    • Concept 22: Reflect: Local Copies of Remote Branches
    • Concept 23: Making a Pull Request
    • Concept 24: Updating a Pull Request
    • Concept 25: Reflect: Collaboration Using GitHub
    • Concept 26: Conflicting Changes
    • Concept 27: Updating Your Local Repository
    • Concept 28: Merging a Pull Request
    • Concept 29: Concept Map: Fork, Fetch, Pull Request
    • Concept 30: Interview with Brent Beer of GitHub
    • Concept 31: Reflect: When to Use a Separate Branch
    • Concept 32: Modifying the Adventure Repository
    • Concept 33: Keeping a Fork Up-To-Date
    • Concept 34: Lesson 3 Summary

Part 13 (Elective): Elective Project: Design a Game

Update:

Due to changes in the Google App Engine platform, the course supporting this project has become out-of-date. Many of the web interfaces and tools depicted in this course have changed. As a result, we have made this project optional for completion of the Full Stack Nanodegree program.

In this project you will use these skills to develop your own game! You will write an API with endpoints that will allow anyone to develop a front-end for your game. Since you aren't required to write a front-end you can use API explorer to test your API.

• Module 01: Developing Scalable Apps with Python
  • Lesson 01: Scalability Basics

    Learn the basics of scalability and discover how Google's App Engine is another tool

    • Concept 01: Welcome to the Course
    • Concept 02: Interview With Urs Pt. 1
    • Concept 03: History of Scaling
    • Concept 04: The Race for Scalability
    • Concept 05: Increasing Capacity
    • Concept 06: Brave New World
    • Concept 07: Problem Solved?
    • Concept 08: A Better Solution
    • Concept 09: The Perfect Solution
    • Concept 10: Reality Check
    • Concept 11: Success Stories
    • Concept 12: Sites Running on App Engine
    • Concept 13: Interview with Mike
    • Concept 14: Outro
    • Concept 15: What did you think?
  • Lesson 02: Getting Started

    Start working with the features available in Google App Engine and deploy your first application.

    • Concept 01: Introduction
    • Concept 02: App Engine Development Cycle
    • Concept 03: Creating AppEngine Project
    • Concept 04: Valid AppEngine IDs
    • Concept 05: Cloud Endpoints
    • Concept 06: Intro to Exercises
    • Concept 07: Set Up Development Environment
    • Concept 08: Introducing Code Repository
    • Concept 09: Explore Project
    • Concept 10: Running Hello Endpoints Project
    • Concept 11: Decorators
    • Concept 12: Overview of Endpoints Code
    • Concept 13: ProtoRPC
    • Concept 14: Overview of Web Frontend
    • Concept 15: Run The Hello World App
    • Concept 16: Add New Endpoints Function
    • Concept 17: Using the GoogleCloudPlatform example
    • Concept 18: Translate API
    • Concept 19: Introducing Conference Central
    • Concept 20: Conference Central Project Layout
    • Concept 21: Exploring ConferenceApi
    • Concept 22: Add ProfileForm Quiz
    • Concept 23: User Authentication
    • Concept 24: Login Functionality
    • Concept 25: Updating saveProfile
    • Concept 26: Outro
  • Lesson 03: Storing and Retrieving Data

    Learn the basics of storing and retrieving data with Google App Engine's Datastore API.

    • Concept 01: Introduction
    • Concept 02: Introducing Datastore
    • Concept 03: Your Experience
    • Concept 04: Kinds, Entities, Properties
    • Concept 05: Modeling Datastore
    • Concept 06: Intro to Exercises
    • Concept 07: Creating Entities
    • Concept 08: Defining Entities in Python
    • Concept 09: Property Types
    • Concept 10: Supported Property Types in NDB
    • Concept 11: Deciding Property Types
    • Concept 12: Implicit and Explicit Keys
    • Concept 13: Choosing Keys
    • Concept 14: Saving Entity to the Data Store
    • Concept 15: Saving Data Conclusion
    • Concept 16: Conflicting Keys
    • Concept 17: Getting Entity from Datastore
    • Concept 18: Frontends and Backends
    • Concept 19: Configuring Credentials
    • Concept 20: Multiple Client IDs
    • Concept 21: Outro
  • Lesson 04: Advanced Datastore Concepts

    Work with some of the more advanced features Google App Engine's Datastore provides, such as filtering and indexes.

    • Concept 01: Introduction
    • Concept 02: Data Relationships
    • Concept 03: Intro to Exercises
    • Concept 04: Create Conferences
    • Concept 05: createConference function
    • Concept 06: Types of Queries
    • Concept 07: Query Conferences
    • Concept 08: Filter by ancestor
    • Concept 09: Filtering by Property Theory
    • Concept 10: Filter by property
    • Concept 11: Recap On Queries
    • Concept 12: Indexes
    • Concept 13: Indexes and Storage
    • Concept 14: Suppressing Single Property Indexes
    • Concept 15: Composite Indexes
    • Concept 16: Deploy non-existing Composite Index
    • Concept 17: Fixing Index Problems
    • Concept 18: Query Restrictions
    • Concept 19: Exploring Query Restrictions
    • Concept 20: Write a Query
    • Concept 21: Dynamic Filters
    • Concept 22: Using Filters
    • Concept 23: Datastore Layers
    • Concept 24: Datastore Commit Process
    • Concept 25: Strong Consistency Diagram
    • Concept 26: Deciding on Data Model
    • Concept 27: Transactions
    • Concept 28: Using Transactions
    • Concept 29: Wrapping Up Transactions
    • Concept 30: Query for Conferences to Attend
    • Concept 31: Unregistering From a Conference
    • Concept 32: Outro
  • Lesson 05: Advanced App Engine Topics

    Work with the more advanced features of the Google App Engine platform, such as memcache and pull queues.

    • Concept 01: Introduction
    • Concept 02: Memcache
    • Concept 03: Intro to Exercises
    • Concept 04: NDB and Memcache
    • Concept 05: Announcements
    • Concept 06: Storing Announcements in Memcache
    • Concept 07: Task Queues & Cron Jobs
    • Concept 08: When To Use Task Queue
    • Concept 09: Push Queues
    • Concept 10: Add Push Queues to Conference Central
    • Concept 11: Pull Queues
    • Concept 12: Pull Queues
    • Concept 13: Cron Jobs
    • Concept 14: Check Conferences Almost Sold Out
    • Concept 15: Scaling Settings
    • Concept 16: AppStats
    • Concept 17: Edge Caching
    • Concept 18: How To Optimize?
    • Concept 19: Course Outro
• Module 02: Project
  • Lesson 01: Project Prep

    In this project you will use these skills to develop your own game! You will write an API with endpoints that will allow anyone to develop a front-end for your game. Since you aren't required to write a front-end you can use API explorer to test your API.

    Project Description - Design a Game

    Project Rubric - Design a Game

    • Concept 01: Project Overview
    • Concept 02: Design a Game API Project Webcasts

Part 14 (Elective): Elective: Project Webcasts

• Module 01: Tournament Results Webcasts
  • Lesson 01: Tournament Results Webcasts

    • Concept 01: Tournament Results Webcasts
• Module 02: Webcasts: Neighborhood Map
  • Lesson 01: Neighborhood Map Project Webcasts

    Webcasts from coaches to help you with your Neighborhood Map Project.

    Project Description - Neighborhood Map

    Project Rubric - Neighborhood Map

    • Concept 01: Neighborhood Map Project Webcasts Intro
    • Concept 02: Neighborhood Map - Rubric
    • Concept 03: Getting Started
    • Concept 04: Knockout Tutorial Walkthrough
    • Concept 05: Q & A
• Module 03: Webcasts: Item Catalog
  • Lesson 01: Item Catalog Project Webcasts

    • Concept 01: Item Catalog Webcasts
• Module 04: Webcasts: Build a Portfolio Site
  • Lesson 01: Build a Portfolio Site Webcasts

    You will develop a responsive website that will display images, descriptions and links to each of the portfolio projects you will complete throughout the course of your Nanodegree program.

    Project Description - Build a Portfolio Site

    Project Rubric - Build a Portfolio Site

    • Concept 01: About the Webcasts
    • Concept 02: Build a Portfolio - Rubric
    • Concept 03: CSS Basics and Box Model
    • Concept 04: Advanced topic - Flexbox Demo
    • Concept 05: Setting up a Grunt Workflow (Summary)
    • Concept 06: Setting up a Grunt Workflow Demo
    • Concept 07: Setting Up a Gulp Workflow (Summary)
    • Concept 08: Setting up a Gulp Workflow Demo
    • Concept 09: How to Use the Forums